… projection

Closes two `KNOWN PERF GAP` items from PR #2712 + a long-standing qmacro parser
limitation surfaced while implementing them. Net result: spliced order/sort
and select+where chains now beat in-memory SQLite on every headline shape.

Gap 1 — comparator key double-call in `partial_sort`.
  Splice planner inlines pure single-expression keys into a comparator block
  and dispatches to new `top_n_by_with_cmp(arr, K, cmp)` library entry (array
  + iterator variants in `daslib/linq.das`). Direction is encoded by flipping
  the comparator arg order (`_::less(body[v2], body[v1])` for desc); no
  separate `_descending` variant needed, eliminating the secondary wrapper
  lambda the existing desc family adds. Falls back to keyed `top_n_by` when
  the key has side effects or isn't a single-expression lambda.

Gap 2 — projection double-eval in `select + where + terminator`.
  Phase 3d inlined `projection` into `predicate` via peel-substitution; lane
  emitters also cloned `projection` into `valueExpr`, so the projection
  evaluated twice per element on ARRAY / ACCUMULATOR / EARLY_EXIT lanes. The
  where-after-select arm now binds `projection` to a fresh local via a new
  `preConditionStmts` slot (per-element, OUTSIDE the if-wrap), then rewrites
  `projection` to reference that bind — predicate (peel) and valueExpr
  (clone) share the single eval. COUNTER lane is explicitly excluded (no
  body use; extra bind would regress its single-stmt fast path).
  Side-effecty projections still bail to tier 2 (moving them outside the if
  would visibly fire side effects on filter-rejected elements).

Parser bonus — `src/parser/parser_impl.cpp:885`.
  Multi-arg `$($i(a) : T, $i(b) : T) { ... }` qmacro form failed parse with
  `30701: block argument is already declared MACRO TAG` because the parser
  stamped every `$i(...)` in block-arg position with the literal placeholder
  name and dup-checked them before macro tag resolution. Fixed by skipping
  the dup check when `name_at.tag != nullptr` — genuine post-resolution
  dups surface as ordinary local-lookup conflicts during type inference.
  General-purpose; usable by any macro that emits a typed block with N
  tagged-name args.

Tests:
  - 4 new tests in `test_linq_fold_ast.das`: Gap 2 dedup-proof (literal
    `7919` appears exactly once in the spliced body), select+where impure
    bailout + per-element call-count assertion, Gap 1 side-effecting-key
    fallback + correctness.
  - 5 existing AST-shape tests updated to match new emission (top_n_by →
    top_n_by_with_cmp; order_by → order(arr, cmp); order_by_inplace →
    order_inplace).

Benchmarks (100K rows, INTERP):
  - sort_take            m3f 56  → 27 ns/op (2.1×; beats SQL at 38)
  - order_take_desc      m3f 56  → 27 ns/op (2.1×; beats SQL at 38)
  - select_where_order_take m3f 39 → 24 ns/op (1.6×; beats SQL at 36)
  - select_where_sum (NEW) m3 59 / m3f 7 ns/op (8.4× over m3; 5.3× over SQL)
  - select_where_count   m3f 5 ns/op (unchanged — COUNTER lane correctly excluded)

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

build: enable hv by default

…-single-eval

linq_fold: single-eval splice — inline pure keys + dedup select+where projection